home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / io / ObjectInputStream$BlockDataInputStream.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  8.8 KB  |  769 lines
  1. package java.io;
  2.  
  3. class ObjectInputStream$BlockDataInputStream extends InputStream implements DataInput {
  4.    private static final int MAX_BLOCK_SIZE = 1024;
  5.    private static final int MAX_HEADER_SIZE = 5;
  6.    private static final int CHAR_BUF_SIZE = 256;
  7.    private static final int HEADER_BLOCKED = -2;
  8.    private final byte[] buf;
  9.    private final byte[] hbuf;
  10.    private final char[] cbuf;
  11.    private boolean blkmode;
  12.    private int pos;
  13.    private int end;
  14.    private int unread;
  15.    // $FF: renamed from: in java.io.ObjectInputStream.PeekInputStream
  16.    private final ObjectInputStream.PeekInputStream field_0;
  17.    private final DataInputStream din;
  18.    // $FF: synthetic field
  19.    final ObjectInputStream this$0;
  20.  
  21.    ObjectInputStream$BlockDataInputStream(ObjectInputStream var1, InputStream var2) {
  22.       this.this$0 = var1;
  23.       this.buf = new byte[1024];
  24.       this.hbuf = new byte[5];
  25.       this.cbuf = new char[256];
  26.       this.blkmode = false;
  27.       this.pos = 0;
  28.       this.end = -1;
  29.       this.unread = 0;
  30.       this.field_0 = new ObjectInputStream.PeekInputStream(var2);
  31.       this.din = new DataInputStream(this);
  32.    }
  33.  
  34.    boolean setBlockDataMode(boolean var1) throws IOException {
  35.       if (this.blkmode == var1) {
  36.          return this.blkmode;
  37.       } else {
  38.          if (var1) {
  39.             this.pos = 0;
  40.             this.end = 0;
  41.             this.unread = 0;
  42.          } else if (this.pos < this.end) {
  43.             throw new IllegalStateException("unread block data");
  44.          }
  45.  
  46.          this.blkmode = var1;
  47.          return !this.blkmode;
  48.       }
  49.    }
  50.  
  51.    boolean getBlockDataMode() {
  52.       return this.blkmode;
  53.    }
  54.  
  55.    void skipBlockData() throws IOException {
  56.       if (!this.blkmode) {
  57.          throw new IllegalStateException("not in block data mode");
  58.       } else {
  59.          while(this.end >= 0) {
  60.             this.refill();
  61.          }
  62.  
  63.       }
  64.    }
  65.  
  66.    private int readBlockHeader(boolean var1) throws IOException {
  67.       if (ObjectInputStream.access$500(this.this$0)) {
  68.          return -1;
  69.       } else {
  70.          try {
  71.             while(true) {
  72.                int var2 = var1 ? Integer.MAX_VALUE : this.field_0.available();
  73.                if (var2 == 0) {
  74.                   return -2;
  75.                }
  76.  
  77.                int var3 = this.field_0.peek();
  78.                switch (var3) {
  79.                   case 119:
  80.                      if (var2 < 2) {
  81.                         return -2;
  82.                      }
  83.  
  84.                      this.field_0.readFully(this.hbuf, 0, 2);
  85.                      return this.hbuf[1] & 255;
  86.                   case 120:
  87.                   default:
  88.                      if (var3 < 0 || var3 >= 112 && var3 <= 126) {
  89.                         return -1;
  90.                      }
  91.  
  92.                      throw new StreamCorruptedException(String.format("invalid type code: %02X", var3));
  93.                   case 121:
  94.                      this.field_0.read();
  95.                      ObjectInputStream.access$600(this.this$0);
  96.                      break;
  97.                   case 122:
  98.                      if (var2 < 5) {
  99.                         return -2;
  100.                      }
  101.  
  102.                      this.field_0.readFully(this.hbuf, 0, 5);
  103.                      int var4 = Bits.getInt(this.hbuf, 1);
  104.                      if (var4 < 0) {
  105.                         throw new StreamCorruptedException("illegal block data header length: " + var4);
  106.                      }
  107.  
  108.                      return var4;
  109.                }
  110.             }
  111.          } catch (EOFException var5) {
  112.             throw new StreamCorruptedException("unexpected EOF while reading block data header");
  113.          }
  114.       }
  115.    }
  116.  
  117.    private void refill() throws IOException {
  118.       try {
  119.          do {
  120.             this.pos = 0;
  121.             if (this.unread > 0) {
  122.                int var1 = this.field_0.read(this.buf, 0, Math.min(this.unread, 1024));
  123.                if (var1 < 0) {
  124.                   throw new StreamCorruptedException("unexpected EOF in middle of data block");
  125.                }
  126.  
  127.                this.end = var1;
  128.                this.unread -= var1;
  129.             } else {
  130.                int var3 = this.readBlockHeader(true);
  131.                if (var3 >= 0) {
  132.                   this.end = 0;
  133.                   this.unread = var3;
  134.                } else {
  135.                   this.end = -1;
  136.                   this.unread = 0;
  137.                }
  138.             }
  139.          } while(this.pos == this.end);
  140.  
  141.       } catch (IOException var2) {
  142.          this.pos = 0;
  143.          this.end = -1;
  144.          this.unread = 0;
  145.          throw var2;
  146.       }
  147.    }
  148.  
  149.    int currentBlockRemaining() {
  150.       if (this.blkmode) {
  151.          return this.end >= 0 ? this.end - this.pos + this.unread : 0;
  152.       } else {
  153.          throw new IllegalStateException();
  154.       }
  155.    }
  156.  
  157.    int peek() throws IOException {
  158.       if (this.blkmode) {
  159.          if (this.pos == this.end) {
  160.             this.refill();
  161.          }
  162.  
  163.          return this.end >= 0 ? this.buf[this.pos] & 255 : -1;
  164.       } else {
  165.          return this.field_0.peek();
  166.       }
  167.    }
  168.  
  169.    byte peekByte() throws IOException {
  170.       int var1 = this.peek();
  171.       if (var1 < 0) {
  172.          throw new EOFException();
  173.       } else {
  174.          return (byte)var1;
  175.       }
  176.    }
  177.  
  178.    public int read() throws IOException {
  179.       if (this.blkmode) {
  180.          if (this.pos == this.end) {
  181.             this.refill();
  182.          }
  183.  
  184.          return this.end >= 0 ? this.buf[this.pos++] & 255 : -1;
  185.       } else {
  186.          return this.field_0.read();
  187.       }
  188.    }
  189.  
  190.    public int read(byte[] var1, int var2, int var3) throws IOException {
  191.       return this.read(var1, var2, var3, false);
  192.    }
  193.  
  194.    public long skip(long var1) throws IOException {
  195.       long var3 = var1;
  196.  
  197.       while(var3 > 0L) {
  198.          if (this.blkmode) {
  199.             if (this.pos == this.end) {
  200.                this.refill();
  201.             }
  202.  
  203.             if (this.end < 0) {
  204.                break;
  205.             }
  206.  
  207.             int var7 = (int)Math.min(var3, (long)(this.end - this.pos));
  208.             var3 -= (long)var7;
  209.             this.pos += var7;
  210.          } else {
  211.             int var5 = (int)Math.min(var3, 1024L);
  212.             if ((var5 = this.field_0.read(this.buf, 0, var5)) < 0) {
  213.                break;
  214.             }
  215.  
  216.             var3 -= (long)var5;
  217.          }
  218.       }
  219.  
  220.       return var1 - var3;
  221.    }
  222.  
  223.    public int available() throws IOException {
  224.       if (!this.blkmode) {
  225.          return this.field_0.available();
  226.       } else {
  227.          if (this.pos == this.end && this.unread == 0) {
  228.             int var1;
  229.             while((var1 = this.readBlockHeader(false)) == 0) {
  230.             }
  231.  
  232.             switch (var1) {
  233.                case -2:
  234.                   break;
  235.                case -1:
  236.                   this.pos = 0;
  237.                   this.end = -1;
  238.                   break;
  239.                default:
  240.                   this.pos = 0;
  241.                   this.end = 0;
  242.                   this.unread = var1;
  243.             }
  244.          }
  245.  
  246.          int var2 = this.unread > 0 ? Math.min(this.field_0.available(), this.unread) : 0;
  247.          return this.end >= 0 ? this.end - this.pos + var2 : 0;
  248.       }
  249.    }
  250.  
  251.    public void close() throws IOException {
  252.       if (this.blkmode) {
  253.          this.pos = 0;
  254.          this.end = -1;
  255.          this.unread = 0;
  256.       }
  257.  
  258.       this.field_0.close();
  259.    }
  260.  
  261.    int read(byte[] var1, int var2, int var3, boolean var4) throws IOException {
  262.       if (var3 == 0) {
  263.          return 0;
  264.       } else if (this.blkmode) {
  265.          if (this.pos == this.end) {
  266.             this.refill();
  267.          }
  268.  
  269.          if (this.end < 0) {
  270.             return -1;
  271.          } else {
  272.             int var6 = Math.min(var3, this.end - this.pos);
  273.             System.arraycopy(this.buf, this.pos, var1, var2, var6);
  274.             this.pos += var6;
  275.             return var6;
  276.          }
  277.       } else if (var4) {
  278.          int var5 = this.field_0.read(this.buf, 0, Math.min(var3, 1024));
  279.          if (var5 > 0) {
  280.             System.arraycopy(this.buf, 0, var1, var2, var5);
  281.          }
  282.  
  283.          return var5;
  284.       } else {
  285.          return this.field_0.read(var1, var2, var3);
  286.       }
  287.    }
  288.  
  289.    public void readFully(byte[] var1) throws IOException {
  290.       this.readFully(var1, 0, var1.length, false);
  291.    }
  292.  
  293.    public void readFully(byte[] var1, int var2, int var3) throws IOException {
  294.       this.readFully(var1, var2, var3, false);
  295.    }
  296.  
  297.    public void readFully(byte[] var1, int var2, int var3, boolean var4) throws IOException {
  298.       while(var3 > 0) {
  299.          int var5 = this.read(var1, var2, var3, var4);
  300.          if (var5 < 0) {
  301.             throw new EOFException();
  302.          }
  303.  
  304.          var2 += var5;
  305.          var3 -= var5;
  306.       }
  307.  
  308.    }
  309.  
  310.    public int skipBytes(int var1) throws IOException {
  311.       return this.din.skipBytes(var1);
  312.    }
  313.  
  314.    public boolean readBoolean() throws IOException {
  315.       int var1 = this.read();
  316.       if (var1 < 0) {
  317.          throw new EOFException();
  318.       } else {
  319.          return var1 != 0;
  320.       }
  321.    }
  322.  
  323.    public byte readByte() throws IOException {
  324.       int var1 = this.read();
  325.       if (var1 < 0) {
  326.          throw new EOFException();
  327.       } else {
  328.          return (byte)var1;
  329.       }
  330.    }
  331.  
  332.    public int readUnsignedByte() throws IOException {
  333.       int var1 = this.read();
  334.       if (var1 < 0) {
  335.          throw new EOFException();
  336.       } else {
  337.          return var1;
  338.       }
  339.    }
  340.  
  341.    public char readChar() throws IOException {
  342.       if (!this.blkmode) {
  343.          this.pos = 0;
  344.          this.field_0.readFully(this.buf, 0, 2);
  345.       } else if (this.end - this.pos < 2) {
  346.          return this.din.readChar();
  347.       }
  348.  
  349.       char var1 = Bits.getChar(this.buf, this.pos);
  350.       this.pos += 2;
  351.       return var1;
  352.    }
  353.  
  354.    public short readShort() throws IOException {
  355.       if (!this.blkmode) {
  356.          this.pos = 0;
  357.          this.field_0.readFully(this.buf, 0, 2);
  358.       } else if (this.end - this.pos < 2) {
  359.          return this.din.readShort();
  360.       }
  361.  
  362.       short var1 = Bits.getShort(this.buf, this.pos);
  363.       this.pos += 2;
  364.       return var1;
  365.    }
  366.  
  367.    public int readUnsignedShort() throws IOException {
  368.       if (!this.blkmode) {
  369.          this.pos = 0;
  370.          this.field_0.readFully(this.buf, 0, 2);
  371.       } else if (this.end - this.pos < 2) {
  372.          return this.din.readUnsignedShort();
  373.       }
  374.  
  375.       int var1 = Bits.getShort(this.buf, this.pos) & '\uffff';
  376.       this.pos += 2;
  377.       return var1;
  378.    }
  379.  
  380.    public int readInt() throws IOException {
  381.       if (!this.blkmode) {
  382.          this.pos = 0;
  383.          this.field_0.readFully(this.buf, 0, 4);
  384.       } else if (this.end - this.pos < 4) {
  385.          return this.din.readInt();
  386.       }
  387.  
  388.       int var1 = Bits.getInt(this.buf, this.pos);
  389.       this.pos += 4;
  390.       return var1;
  391.    }
  392.  
  393.    public float readFloat() throws IOException {
  394.       if (!this.blkmode) {
  395.          this.pos = 0;
  396.          this.field_0.readFully(this.buf, 0, 4);
  397.       } else if (this.end - this.pos < 4) {
  398.          return this.din.readFloat();
  399.       }
  400.  
  401.       float var1 = Bits.getFloat(this.buf, this.pos);
  402.       this.pos += 4;
  403.       return var1;
  404.    }
  405.  
  406.    public long readLong() throws IOException {
  407.       if (!this.blkmode) {
  408.          this.pos = 0;
  409.          this.field_0.readFully(this.buf, 0, 8);
  410.       } else if (this.end - this.pos < 8) {
  411.          return this.din.readLong();
  412.       }
  413.  
  414.       long var1 = Bits.getLong(this.buf, this.pos);
  415.       this.pos += 8;
  416.       return var1;
  417.    }
  418.  
  419.    public double readDouble() throws IOException {
  420.       if (!this.blkmode) {
  421.          this.pos = 0;
  422.          this.field_0.readFully(this.buf, 0, 8);
  423.       } else if (this.end - this.pos < 8) {
  424.          return this.din.readDouble();
  425.       }
  426.  
  427.       double var1 = Bits.getDouble(this.buf, this.pos);
  428.       this.pos += 8;
  429.       return var1;
  430.    }
  431.  
  432.    public String readUTF() throws IOException {
  433.       return this.readUTFBody((long)this.readUnsignedShort());
  434.    }
  435.  
  436.    public String readLine() throws IOException {
  437.       return this.din.readLine();
  438.    }
  439.  
  440.    void readBooleans(boolean[] var1, int var2, int var3) throws IOException {
  441.       int var5 = var2 + var3;
  442.  
  443.       while(var2 < var5) {
  444.          int var4;
  445.          if (!this.blkmode) {
  446.             int var6 = Math.min(var5 - var2, 1024);
  447.             this.field_0.readFully(this.buf, 0, var6);
  448.             var4 = var2 + var6;
  449.             this.pos = 0;
  450.          } else {
  451.             if (this.end - this.pos < 1) {
  452.                var1[var2++] = this.din.readBoolean();
  453.                continue;
  454.             }
  455.  
  456.             var4 = Math.min(var5, var2 + this.end - this.pos);
  457.          }
  458.  
  459.          while(var2 < var4) {
  460.             var1[var2++] = Bits.getBoolean(this.buf, this.pos++);
  461.          }
  462.       }
  463.  
  464.    }
  465.  
  466.    void readChars(char[] var1, int var2, int var3) throws IOException {
  467.       int var5 = var2 + var3;
  468.  
  469.       while(var2 < var5) {
  470.          int var4;
  471.          if (!this.blkmode) {
  472.             int var6 = Math.min(var5 - var2, 512);
  473.             this.field_0.readFully(this.buf, 0, var6 << 1);
  474.             var4 = var2 + var6;
  475.             this.pos = 0;
  476.          } else {
  477.             if (this.end - this.pos < 2) {
  478.                var1[var2++] = this.din.readChar();
  479.                continue;
  480.             }
  481.  
  482.             var4 = Math.min(var5, var2 + (this.end - this.pos >> 1));
  483.          }
  484.  
  485.          while(var2 < var4) {
  486.             var1[var2++] = Bits.getChar(this.buf, this.pos);
  487.             this.pos += 2;
  488.          }
  489.       }
  490.  
  491.    }
  492.  
  493.    void readShorts(short[] var1, int var2, int var3) throws IOException {
  494.       int var5 = var2 + var3;
  495.  
  496.       while(var2 < var5) {
  497.          int var4;
  498.          if (!this.blkmode) {
  499.             int var6 = Math.min(var5 - var2, 512);
  500.             this.field_0.readFully(this.buf, 0, var6 << 1);
  501.             var4 = var2 + var6;
  502.             this.pos = 0;
  503.          } else {
  504.             if (this.end - this.pos < 2) {
  505.                var1[var2++] = this.din.readShort();
  506.                continue;
  507.             }
  508.  
  509.             var4 = Math.min(var5, var2 + (this.end - this.pos >> 1));
  510.          }
  511.  
  512.          while(var2 < var4) {
  513.             var1[var2++] = Bits.getShort(this.buf, this.pos);
  514.             this.pos += 2;
  515.          }
  516.       }
  517.  
  518.    }
  519.  
  520.    void readInts(int[] var1, int var2, int var3) throws IOException {
  521.       int var5 = var2 + var3;
  522.  
  523.       while(var2 < var5) {
  524.          int var4;
  525.          if (!this.blkmode) {
  526.             int var6 = Math.min(var5 - var2, 256);
  527.             this.field_0.readFully(this.buf, 0, var6 << 2);
  528.             var4 = var2 + var6;
  529.             this.pos = 0;
  530.          } else {
  531.             if (this.end - this.pos < 4) {
  532.                var1[var2++] = this.din.readInt();
  533.                continue;
  534.             }
  535.  
  536.             var4 = Math.min(var5, var2 + (this.end - this.pos >> 2));
  537.          }
  538.  
  539.          while(var2 < var4) {
  540.             var1[var2++] = Bits.getInt(this.buf, this.pos);
  541.             this.pos += 4;
  542.          }
  543.       }
  544.  
  545.    }
  546.  
  547.    void readFloats(float[] var1, int var2, int var3) throws IOException {
  548.       int var5 = var2 + var3;
  549.  
  550.       while(var2 < var5) {
  551.          int var4;
  552.          if (!this.blkmode) {
  553.             var4 = Math.min(var5 - var2, 256);
  554.             this.field_0.readFully(this.buf, 0, var4 << 2);
  555.             this.pos = 0;
  556.          } else {
  557.             if (this.end - this.pos < 4) {
  558.                var1[var2++] = this.din.readFloat();
  559.                continue;
  560.             }
  561.  
  562.             var4 = Math.min(var5 - var2, this.end - this.pos >> 2);
  563.          }
  564.  
  565.          ObjectInputStream.access$700(this.buf, this.pos, var1, var2, var4);
  566.          var2 += var4;
  567.          this.pos += var4 << 2;
  568.       }
  569.  
  570.    }
  571.  
  572.    void readLongs(long[] var1, int var2, int var3) throws IOException {
  573.       int var5 = var2 + var3;
  574.  
  575.       while(var2 < var5) {
  576.          int var4;
  577.          if (!this.blkmode) {
  578.             int var6 = Math.min(var5 - var2, 128);
  579.             this.field_0.readFully(this.buf, 0, var6 << 3);
  580.             var4 = var2 + var6;
  581.             this.pos = 0;
  582.          } else {
  583.             if (this.end - this.pos < 8) {
  584.                var1[var2++] = this.din.readLong();
  585.                continue;
  586.             }
  587.  
  588.             var4 = Math.min(var5, var2 + (this.end - this.pos >> 3));
  589.          }
  590.  
  591.          while(var2 < var4) {
  592.             var1[var2++] = Bits.getLong(this.buf, this.pos);
  593.             this.pos += 8;
  594.          }
  595.       }
  596.  
  597.    }
  598.  
  599.    void readDoubles(double[] var1, int var2, int var3) throws IOException {
  600.       int var5 = var2 + var3;
  601.  
  602.       while(var2 < var5) {
  603.          int var4;
  604.          if (!this.blkmode) {
  605.             var4 = Math.min(var5 - var2, 128);
  606.             this.field_0.readFully(this.buf, 0, var4 << 3);
  607.             this.pos = 0;
  608.          } else {
  609.             if (this.end - this.pos < 8) {
  610.                var1[var2++] = this.din.readDouble();
  611.                continue;
  612.             }
  613.  
  614.             var4 = Math.min(var5 - var2, this.end - this.pos >> 3);
  615.          }
  616.  
  617.          ObjectInputStream.access$800(this.buf, this.pos, var1, var2, var4);
  618.          var2 += var4;
  619.          this.pos += var4 << 3;
  620.       }
  621.  
  622.    }
  623.  
  624.    String readLongUTF() throws IOException {
  625.       return this.readUTFBody(this.readLong());
  626.    }
  627.  
  628.    private String readUTFBody(long var1) throws IOException {
  629.       StringBuilder var3 = new StringBuilder();
  630.       if (!this.blkmode) {
  631.          this.end = this.pos = 0;
  632.       }
  633.  
  634.       while(var1 > 0L) {
  635.          int var4 = this.end - this.pos;
  636.          if (var4 < 3 && (long)var4 != var1) {
  637.             if (this.blkmode) {
  638.                var1 -= (long)this.readUTFChar(var3, var1);
  639.             } else {
  640.                if (var4 > 0) {
  641.                   System.arraycopy(this.buf, this.pos, this.buf, 0, var4);
  642.                }
  643.  
  644.                this.pos = 0;
  645.                this.end = (int)Math.min(1024L, var1);
  646.                this.field_0.readFully(this.buf, var4, this.end - var4);
  647.             }
  648.          } else {
  649.             var1 -= this.readUTFSpan(var3, var1);
  650.          }
  651.       }
  652.  
  653.       return var3.toString();
  654.    }
  655.  
  656.    private long readUTFSpan(StringBuilder var1, long var2) throws IOException {
  657.       int var4 = 0;
  658.       int var5 = this.pos;
  659.       int var6 = Math.min(this.end - this.pos, 256);
  660.       int var7 = this.pos + (var2 > (long)var6 ? var6 - 2 : (int)var2);
  661.       boolean var8 = false;
  662.  
  663.       try {
  664.          while(this.pos < var7) {
  665.             int var9 = this.buf[this.pos++] & 255;
  666.             switch (var9 >> 4) {
  667.                case 0:
  668.                case 1:
  669.                case 2:
  670.                case 3:
  671.                case 4:
  672.                case 5:
  673.                case 6:
  674.                case 7:
  675.                   this.cbuf[var4++] = (char)var9;
  676.                   break;
  677.                case 8:
  678.                case 9:
  679.                case 10:
  680.                case 11:
  681.                default:
  682.                   throw new UTFDataFormatException();
  683.                case 12:
  684.                case 13:
  685.                   byte var17 = this.buf[this.pos++];
  686.                   if ((var17 & 192) != 128) {
  687.                      throw new UTFDataFormatException();
  688.                   }
  689.  
  690.                   this.cbuf[var4++] = (char)((var9 & 31) << 6 | (var17 & 63) << 0);
  691.                   break;
  692.                case 14:
  693.                   byte var11 = this.buf[this.pos + 1];
  694.                   byte var10 = this.buf[this.pos + 0];
  695.                   this.pos += 2;
  696.                   if ((var10 & 192) != 128 || (var11 & 192) != 128) {
  697.                      throw new UTFDataFormatException();
  698.                   }
  699.  
  700.                   this.cbuf[var4++] = (char)((var9 & 15) << 12 | (var10 & 63) << 6 | (var11 & 63) << 0);
  701.             }
  702.          }
  703.       } catch (ArrayIndexOutOfBoundsException var15) {
  704.          var8 = true;
  705.       } finally {
  706.          if (var8 || (long)(this.pos - var5) > var2) {
  707.             this.pos = var5 + (int)var2;
  708.             throw new UTFDataFormatException();
  709.          }
  710.  
  711.       }
  712.  
  713.       var1.append(this.cbuf, 0, var4);
  714.       return (long)(this.pos - var5);
  715.    }
  716.  
  717.    private int readUTFChar(StringBuilder var1, long var2) throws IOException {
  718.       int var4 = this.readByte() & 255;
  719.       switch (var4 >> 4) {
  720.          case 0:
  721.          case 1:
  722.          case 2:
  723.          case 3:
  724.          case 4:
  725.          case 5:
  726.          case 6:
  727.          case 7:
  728.             var1.append((char)var4);
  729.             return 1;
  730.          case 8:
  731.          case 9:
  732.          case 10:
  733.          case 11:
  734.          default:
  735.             throw new UTFDataFormatException();
  736.          case 12:
  737.          case 13:
  738.             if (var2 < 2L) {
  739.                throw new UTFDataFormatException();
  740.             } else {
  741.                byte var7 = this.readByte();
  742.                if ((var7 & 192) != 128) {
  743.                   throw new UTFDataFormatException();
  744.                }
  745.  
  746.                var1.append((char)((var4 & 31) << 6 | (var7 & 63) << 0));
  747.                return 2;
  748.             }
  749.          case 14:
  750.             if (var2 < 3L) {
  751.                if (var2 == 2L) {
  752.                   this.readByte();
  753.                }
  754.  
  755.                throw new UTFDataFormatException();
  756.             } else {
  757.                byte var5 = this.readByte();
  758.                byte var6 = this.readByte();
  759.                if ((var5 & 192) == 128 && (var6 & 192) == 128) {
  760.                   var1.append((char)((var4 & 15) << 12 | (var5 & 63) << 6 | (var6 & 63) << 0));
  761.                   return 3;
  762.                } else {
  763.                   throw new UTFDataFormatException();
  764.                }
  765.             }
  766.       }
  767.    }
  768. }
  769.